{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantization Neural Network with Eve\n",
    "\n",
    "In this script, we will build a quantization neural network with eve-mli,\n",
    "different kinds of quantization function will be compared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import necessary packages.\n",
    "# at the beginning, ensure that the eve-mli package is in your python path.\n",
    "# or you just install it via `pip install eve-mli`.\n",
    "\n",
    "import os\n",
    "import time\n",
    "from datetime import datetime\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "import torch as th\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import eve\n",
    "import eve.app\n",
    "import eve.app.model\n",
    "import eve.app.trainer\n",
    "import eve.core\n",
    "import eve.app.space as space\n",
    "import eve.core.layer\n",
    "import eve.core.quan\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build a basic network for trainer, use Poisson Encoder as default\n",
    "class mnist(eve.core.Eve):\n",
    "    def __init__(self,\n",
    "            quan_on_a: bool = True,\n",
    "            quan_on_w: bool = True,\n",
    "            bits: int = 8,\n",
    "            quantize_fn: str = \"Round\",\n",
    "            range_tracker: str = \"average_tracker\",\n",
    "            average_tracker_momentum: float = 0.1,\n",
    "            upgrade_bits: bool = False,\n",
    "            neuron_wise: bool = False,\n",
    "            asymmetric: bool = False,\n",
    "            signed_quantization: bool = False,\n",
    "            learnable_alpha: bool = None,\n",
    "            upgrade_fn: callable = None,\n",
    "            **kwargs,):\n",
    "        super().__init__()\n",
    " \n",
    "        def build_quantizer(state):\n",
    "            return eve.core.quan.Quantizer(state, \n",
    "                         bits = bits,\n",
    "                         quantize_fn = quantize_fn,\n",
    "                         range_tracker = range_tracker,\n",
    "                         average_tracker_momentum = average_tracker_momentum,\n",
    "                         upgrade_bits = upgrade_bits,\n",
    "                         neuron_wise = neuron_wise,\n",
    "                         asymmetric = asymmetric,\n",
    "                         signed_quantization = signed_quantization,\n",
    "                         learnable_alpha = learnable_alpha,\n",
    "                         upgrade_fn = upgrade_fn,\n",
    "                         **kwargs,)\n",
    "        if quan_on_w:\n",
    "            self.conv1 = eve.core.layer.QuanBNFuseConv2d(1, 4, 3, stride=2, padding=1)\n",
    "            self.conv1.assign_quantizer(\n",
    "                build_quantizer(eve.core.State(self.conv1, apply_on=\"param\")))\n",
    "        else:\n",
    "            self.conv1 = nn.Sequential(nn.Conv2d(1, 4, 3, stride=2, padding=1), nn.BatchNorm2d(4))\n",
    "        self.relu1 = nn.ReLU()\n",
    "        if quan_on_a:\n",
    "            self.act_quan1 = build_quantizer(eve.core.State(self.conv1, apply_on=\"data\"))\n",
    "        else:\n",
    "            self.act_quan1 = nn.Sequential()\n",
    "\n",
    "        if quan_on_w:\n",
    "            self.conv2 = eve.core.layer.QuanBNFuseConv2d(4, 8, 3, stride=2, padding=1)\n",
    "            self.conv2.assign_quantizer(\n",
    "                build_quantizer(eve.core.State(self.conv2, apply_on=\"param\")))\n",
    "        else:\n",
    "            self.conv2 = nn.Sequential(nn.Conv2d(4, 8, 3, stride=2, padding=1), nn.BatchNorm2d(8))\n",
    "        self.relu2 = nn.ReLU()\n",
    "        if quan_on_a:\n",
    "            self.act_quan2 = build_quantizer(eve.core.State(self.conv2, apply_on=\"data\"))\n",
    "        else:\n",
    "            self.act_quan2 = nn.Sequential()\n",
    "            \n",
    "        if quan_on_w:\n",
    "            self.conv3 = eve.core.layer.QuanBNFuseConv2d(8, 16, 3, stride=2, padding=1)\n",
    "            self.conv3.assign_quantizer(\n",
    "                build_quantizer(eve.core.State(self.conv3, apply_on=\"param\")))\n",
    "        else:\n",
    "            self.conv3 = nn.Sequential(nn.Conv2d(8, 16, 3, stride=2, padding=1), nn.BatchNorm2d(16))\n",
    "        self.relu3 = nn.ReLU()\n",
    "        if quan_on_a:\n",
    "            self.act_quan3 = build_quantizer(eve.core.State(self.conv3, apply_on=\"data\"))\n",
    "        else:\n",
    "            self.act_quan3 = nn.Sequential()\n",
    "\n",
    "        if quan_on_w:\n",
    "            self.linear1 = eve.core.layer.QuanLinear(16 * 4 * 4, 16)\n",
    "            self.linear1.assign_quantizer(\n",
    "                build_quantizer(eve.core.State(self.linear1, apply_on=\"param\")))\n",
    "        else:\n",
    "            self.linear1 = nn.Linear(16 * 4 * 4, 16)\n",
    "        self.relu4 = nn.ReLU()\n",
    "        if quan_on_a:\n",
    "            self.act_quan4 = build_quantizer(eve.core.State(self.linear1, apply_on=\"data\"))\n",
    "        else:\n",
    "            self.act_quan4 = nn.Sequential()\n",
    "        \n",
    "        self.linear2 = nn.Linear(16, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        conv1 = self.conv1(x)\n",
    "        relu1 = self.relu1(conv1)\n",
    "        act_quan1 = self.act_quan1(relu1)\n",
    "\n",
    "        conv2 = self.conv2(act_quan1)\n",
    "        relu2 = self.relu2(conv2)\n",
    "        act_quan2 = self.act_quan2(relu2)\n",
    "\n",
    "        conv3 = self.conv3(act_quan2)\n",
    "        relu3 = self.relu3(conv3)\n",
    "        act_quan3 = self.act_quan3(relu3)\n",
    "\n",
    "        act_quan3 = th.flatten(act_quan3, start_dim=1).unsqueeze(dim=1)\n",
    "\n",
    "        linear1 = self.linear1(act_quan3)\n",
    "        relu4 = self.relu4(linear1)\n",
    "        act_quan4 = self.act_quan4(relu4)\n",
    "\n",
    "        linear2 = self.linear2(act_quan4)\n",
    "\n",
    "        return linear2.squeeze(dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a MnistClassifier\n",
    "# Classifier uses the corss entropy as default.\n",
    "# in most case, we just rewrite the `prepare_data`.\n",
    "class MnistClassifier(eve.app.model.Classifier):\n",
    "    def prepare_data(self, data_root: str):\n",
    "        from torch.utils.data import DataLoader, random_split\n",
    "        from torchvision import transforms\n",
    "        from torchvision.datasets import MNIST\n",
    "\n",
    "        train_dataset = MNIST(root=data_root,\n",
    "                              train=True,\n",
    "                              download=True,\n",
    "                              transform=transforms.ToTensor())\n",
    "        test_dataset = MNIST(root=data_root,\n",
    "                             train=False,\n",
    "                             download=True,\n",
    "                             transform=transforms.ToTensor())\n",
    "        self.train_dataset, self.valid_dataset = random_split(\n",
    "            train_dataset, [55000, 5000])\n",
    "        self.test_dataset = test_dataset\n",
    "\n",
    "        self.train_dataloader = DataLoader(self.train_dataset,\n",
    "                                           batch_size=128,\n",
    "                                           shuffle=True,\n",
    "                                           num_workers=4)\n",
    "        self.test_dataloader = DataLoader(self.test_dataset,\n",
    "                                          batch_size=128,\n",
    "                                          shuffle=False,\n",
    "                                          num_workers=4)\n",
    "        self.valid_dataloader = DataLoader(self.valid_dataset,\n",
    "                                           batch_size=128,\n",
    "                                           shuffle=False,\n",
    "                                           num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# store accuracy result\n",
    "y = {}\n",
    "def plot():\n",
    "    global y\n",
    "    keys, values = list(y.keys()), list(y.values())\n",
    "    for k, v in y.items():\n",
    "        plt.plot(v, \n",
    "                 color='green' if random.random() > 0.5 else \"red\", \n",
    "                 marker='o' if random.random() > 0.5 else \"*\", \n",
    "                 linestyle='-' if random.random() > 0.5 else \":\", \n",
    "                 label=k)\n",
    "    plt.title('accuracy over epoches (train)')\n",
    "    plt.xlabel('epochs')\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.legend(loc=\"upper left\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(net, exp_name: str = \"quan\", data_root: str = \"/home/densechen/dataset\"):\n",
    "    global y\n",
    "    # replace the data_root for your path.\n",
    "    classifier = MnistClassifier(net)\n",
    "    classifier.prepare_data(data_root=data_root)\n",
    "    \n",
    "    # use default configuration\n",
    "    # use a smaller lr for that alpha is unstable during training\n",
    "    classifier.setup_train(lr=1e-4)\n",
    "    \n",
    "    # assign model to trainer\n",
    "    eve.app.trainer.BaseTrainer.assign_model(classifier)\n",
    "    \n",
    "    trainer = eve.app.trainer.BaseTrainer()\n",
    "    \n",
    "    # train 10 epoches and report the final accuracy\n",
    "    y[exp_name] = []\n",
    "    tic = datetime.now()\n",
    "    for _ in range(10):\n",
    "        info = trainer.fit()\n",
    "        y[exp_name].append(info[\"acc\"])\n",
    "    info = trainer.test()\n",
    "    toc = datetime.now()\n",
    "    y[exp_name] = np.array(y[exp_name])\n",
    "    print(f\"Test Accuracy: {info['acc']*100:.2f}%, Elapsed time: {toc-tic}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quan param vs Quan act"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Quantization on param\n",
      "Test Accuracy: 83.58%, Elapsed time: 0:01:41.564670\n",
      "===> Quantization on act\n",
      "Test Accuracy: 96.52%, Elapsed time: 0:01:15.718537\n",
      "===> Quantization on both\n",
      "Test Accuracy: 83.30%, Elapsed time: 0:02:08.939456\n",
      "===> Quantization on neither\n",
      "Test Accuracy: 96.59%, Elapsed time: 0:00:46.188178\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reset y\n",
    "y = {}\n",
    "\n",
    "# define quantization neural network with quantize param, quantize act and quantize on both\n",
    "quantization_neural_network_param = mnist(quan_on_w=True, quan_on_a=False).quantize()\n",
    "quantization_neural_network_act = mnist(quan_on_w=False, quan_on_a=True).quantize()\n",
    "quantization_neural_network_both = mnist(quan_on_w=True, quan_on_a=True).quantize()\n",
    "quantization_neural_network_neither = mnist(quan_on_w=False, quan_on_a=False).quantize()\n",
    "# or\n",
    "# quantization_neural_network_neither = mnist().non_quanitze()\n",
    "\n",
    "print(\"===> Quantization on param\")\n",
    "train(quantization_neural_network_param, \"param\")\n",
    "\n",
    "print(\"===> Quantization on act\")\n",
    "train(quantization_neural_network_act, \"act\")\n",
    "\n",
    "print(\"===> Quantization on both\")\n",
    "train(quantization_neural_network_both, \"both\")\n",
    "\n",
    "print(\"===> Quantization on neither\")\n",
    "train(quantization_neural_network_neither, \"neither\")\n",
    "\n",
    "plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Round vs LSQ vs LLSQ on act only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Quantization with Round\n",
      "Test Accuracy: 95.72%, Elapsed time: 0:01:14.043124\n",
      "===> Quantization with lsq\n",
      "Test Accuracy: 94.90%, Elapsed time: 0:01:24.896148\n",
      "===> Quantization with llsq_l1\n",
      "Test Accuracy: 95.08%, Elapsed time: 0:02:05.949373\n",
      "===> Quantization with llsq_l2\n",
      "Test Accuracy: 95.35%, Elapsed time: 0:02:11.568797\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reset y\n",
    "y = {}\n",
    "\n",
    "# define quantization neural network with different quantization function\n",
    "quantization_neural_network_round = mnist(quan_on_w=False, quantize_fn=\"Round\").quantize()\n",
    "quantization_neural_network_lsq = mnist(quan_on_w=False, quantize_fn=\"Lsq\").quantize()\n",
    "quantization_neural_network_llsq_l1 = mnist(quan_on_w=False, quantize_fn=\"Llsq\", regular=\"l1\").quantize()\n",
    "quantization_neural_network_llsq_l2 = mnist(quan_on_w=False, quantize_fn=\"Llsq\", regular=\"l2\").quantize()\n",
    "\n",
    "print(\"===> Quantization with Round\")\n",
    "train(quantization_neural_network_round, \"Round\")\n",
    "\n",
    "print(\"===> Quantization with lsq\")\n",
    "train(quantization_neural_network_lsq, \"lsq\")\n",
    "\n",
    "print(\"===> Quantization with llsq_l1\")\n",
    "train(quantization_neural_network_llsq_l1, \"llsq_l1\")\n",
    "\n",
    "print(\"===> Quantization with llsq_l2\")\n",
    "train(quantization_neural_network_llsq_l2, \"llsq_l2\")\n",
    "\n",
    "plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Average tracker vs Global tracker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Quantization with average range tracker\n",
      "Test Accuracy: 82.03%, Elapsed time: 0:02:10.593734\n",
      "===> Quantization with global range tracker\n",
      "Test Accuracy: 84.06%, Elapsed time: 0:02:12.500429\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reset y\n",
    "y = {}\n",
    "\n",
    "# define quantization neural network with different quantization function\n",
    "quantization_neural_network_average_tracker = mnist(range_tracker=\"average_tracker\").quantize()\n",
    "quantization_neural_network_global_tracker = mnist(range_tracker=\"global_tracker\").quantize()\n",
    "\n",
    "print(\"===> Quantization with average range tracker\")\n",
    "train(quantization_neural_network_average_tracker, \"average\")\n",
    "\n",
    "print(\"===> Quantization with global range tracker\")\n",
    "train(quantization_neural_network_global_tracker, \"global\")\n",
    "\n",
    "plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Round with with different bits¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Quantization with 2 bits\n",
      "Test Accuracy: 45.51%, Elapsed time: 0:02:10.259819\n",
      "===> Quantization with 4 bits\n",
      "Test Accuracy: 71.16%, Elapsed time: 0:02:08.941098\n",
      "===> Quantization with 8 bits\n",
      "Test Accuracy: 81.84%, Elapsed time: 0:02:07.281995\n",
      "===> Quantization with full precision\n",
      "Test Accuracy: 96.11%, Elapsed time: 0:01:40.056623\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reset y\n",
    "y = {}\n",
    "\n",
    "# define quantization neural network with different configuration\n",
    "quantization_neural_network_bits_2 = mnist(bits=2).quantize()\n",
    "quantization_neural_network_bits_4 = mnist(bits=4).quantize()\n",
    "quantization_neural_network_bits_8 = mnist(bits=8).quantize()\n",
    "quantization_neural_network_full_precision = mnist().non_quantize()\n",
    "\n",
    "print(\"===> Quantization with 2 bits\")\n",
    "train(quantization_neural_network_bits_2, \"2 bits\")\n",
    "\n",
    "print(\"===> Quantization with 4 bits\")\n",
    "train(quantization_neural_network_bits_4, \"4 bits\")\n",
    "\n",
    "print(\"===> Quantization with 8 bits\")\n",
    "train(quantization_neural_network_bits_8, \"8 bits\")\n",
    "\n",
    "print(\"===> Quantization with full precision\")\n",
    "train(quantization_neural_network_full_precision, \"full precision\")\n",
    "\n",
    "plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## quan with other arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Quantization with neuron wise\n",
      "Test Accuracy: 95.60%, Elapsed time: 0:01:39.704981\n",
      "===> Quantization with neuron share\n",
      "Test Accuracy: 95.79%, Elapsed time: 0:01:48.575900\n",
      "===> Quantization with asymmetric\n",
      "Test Accuracy: 95.84%, Elapsed time: 0:01:32.690768\n",
      "===> Quantization with symmetric\n",
      "Test Accuracy: 96.14%, Elapsed time: 0:01:42.991659\n",
      "===> Quantization with signed quantization\n",
      "Test Accuracy: 95.88%, Elapsed time: 0:01:51.287698\n",
      "===> Quantization with unsigned quantization\n",
      "Test Accuracy: 95.60%, Elapsed time: 0:01:36.948094\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reset y\n",
    "y = {}\n",
    "\n",
    "# define quantization neural network\n",
    "quantization_neural_network_neuron_wise = mnist(neuron_wise=True)\n",
    "quantization_neural_network_neuron_share = mnist(neuron_wise=False)\n",
    "\n",
    "quantization_neural_network_asymmetric = mnist(asymmetric=True)\n",
    "quantization_neural_network_symmetric = mnist(asymmetric=False)\n",
    "\n",
    "quantization_neural_network_signed_quantization = mnist(signed_quantization=True)\n",
    "quantization_neural_network_unsigned_quantization = mnist(signed_quantization=False)\n",
    "\n",
    "print(\"===> Quantization with neuron wise\")\n",
    "train(quantization_neural_network_neuron_wise, \"neuron wise\")\n",
    "\n",
    "print(\"===> Quantization with neuron share\")\n",
    "train(quantization_neural_network_neuron_share, \"neuron share\")\n",
    "\n",
    "print(\"===> Quantization with asymmetric\")\n",
    "train(quantization_neural_network_asymmetric, \"asymmetric\")\n",
    "\n",
    "print(\"===> Quantization with symmetric\")\n",
    "train(quantization_neural_network_symmetric, \"symmetric\")\n",
    "\n",
    "print(\"===> Quantization with signed quantization\")\n",
    "train(quantization_neural_network_signed_quantization, \"signed\")\n",
    "\n",
    "print(\"===> Quantization with unsigned quantization\")\n",
    "train(quantization_neural_network_unsigned_quantization, \"unsigned\")\n",
    "\n",
    "plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
